/*
对于任意的真分数 N/M （ 0 < N < M ），均可以求出对应的小数。如果采用链表表示各个小数，对于循环节采用循环链表表示，则所有分数均可以表示为如下链表形式。

![](图片1)

输入： N M k

输出： 转换后的小数（不超过 k ）

要求： 仅编写将分数转换为小数的函数 change( int n, int m, NODE * head ) 。
*/

/*
测试用例1:
输入：
1 8 50↵
输出：
0.125↵

测试用例2：
输入：
29 33 10↵
输出：
0.8787878787↵

测试用例3：
输入：
7 18 52↵
输出：
0.3888888888888888888888888888888888888888888888888888↵

测试用例4:
输入：
2 7 50↵
输出：
0.28571428571428571428571428571428571428571428571428↵
*/

// 预设代码
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */  
 
#include <stdio.h>  
#include <stdlib.h>
#include <vector>

using namespace std;

// 节点
typedef struct node
{
    int data; // 数据
    struct node * next; // 指针
} NODE;
  
void output( NODE *, int ); // 打印
void change( int, int, NODE * ); // 依据除法，创建链表

// 打印链表信息
void output( NODE * head, int kk )
{
    // 记录输出的长度
    int k=0;
    
    printf("0.");
    
    // 遍历链表
    while ( head->next != NULL && k<kk )
    {
        printf("%d", head->next->data );
        head = head->next;
        k ++;
    }
    printf("\n");  
}

// 判断商和余数是否记录在案，如果记录在案，返回位置索引，否则返回-1
int find_common(int e, int n, vector<int> quotinents, vector<int> remainders)
{
    for (int i=0;i<quotinents.size();i++)
    {
        if ( e == quotinents[i] && n == remainders[i])
            return i;
    }
    return -1;
}

// 依据序号，查找链表中的节点
NODE * find_node(NODE * head, int id)
{
    NODE * p = head;
    for (int i=0; i<=id; i++)
    {
        p = p->next;
    }
    return p;
}

// 依据除法，创建链表
void change(int n, int m, NODE * head)
{
    // 记录元素
    int e;
    
    // 记录位置索引
    int id;
    
    // 辅助节点
    NODE * p = head;
    
    vector<int> quotients;
    vector<int> remainders;
    
    while(1)
    {
        n = 10 * n;
        
        // 获取商
        e = n / m;
        
        // 获取余数
        n = n % m;
        
        // 判断商和余数是否记录在案，如果记录在案，返回位置索引，否则返回-1
        id = find_common(e, n, quotients, remainders);
        
        if (id == -1)
        {
            // 记录
            quotients.push_back(e);
            remainders.push_back(n);
            
            // 添加节点
            NODE * new_node = new NODE;
            new_node->data = e;
            new_node->next = NULL;
            p->next = new_node;
            p = p->next;
        }
        else
        {
            NODE * node = find_node(head, id);
            p->next = node;
            break;
        }
      
        // 可除尽
        if (n == 0)
          break;
    }
    
}

int main()  
{
    int n, m, k;
    
    // 链表
    NODE * head;  
    
    // 用户输入
    scanf("%d%d%d", &n, &m, &k);
    
    // 初始化头节点
    head = (NODE *)malloc( sizeof(NODE) );
    head->next = NULL;
    head->data = -1;
    
    // 依据除法，创建链表
    change( n, m, head );
    
    // 打印
    output( head, k );
    return 0;
}  
  
/* PRESET CODE END - NEVER TOUCH CODE ABOVE */ 